"""
对话智能体

处理一般对话、概念解释、问答交互等非分析类请求，直接返回响应。
"""

import re
from typing import Dict, Any, List, Optional
from langchain_core.prompts import PromptTemplate
from langchain_core.messages import BaseMessage, HumanMessage, SystemMessage

from agents import BaseAgent, LLMConfig


# 对话处理prompt模板
CONVERSATION_PROMPT = PromptTemplate.from_template("""
你是一个专业的债券分析助手，负责处理用户的对话请求。

你的角色：
- 债券分析专家：具备丰富的债券市场知识
- 友好助手：用亲切友好的语气与用户交流
- 知识传播者：能够解释复杂的债券概念

对话场景分类：
1. **问候对话**：你好、您好、在吗、hi、hello
2. **感谢对话**：谢谢、感谢、多谢、好的、知道了
3. **能力询问**：你能做什么、有什么功能、如何使用、怎么用
4. **概念解释**：什么是、能解释、介绍一下、是什么意思
5. **一般咨询**：其他非分析类的债券相关问题

用户输入：{user_input}

对话历史上下文：
{conversation_history}

请根据用户输入和对话历史，提供专业、准确、友好的回答。

回答要求：
- 保持专业性和准确性
- 使用亲切友好的语气
- 如果涉及复杂概念，用通俗易懂的方式解释
- 对于能力询问，简要介绍主要功能
- 对于概念解释，提供清晰的定义和示例

请直接返回回答内容，不要包含额外的格式标记。
""")


class GeneralConversationalAgent(BaseAgent):
    """通用对话智能体"""
    
    def __init__(self, llm_config: Optional[LLMConfig] = None):
        super().__init__(
            name="conversational",
            description="处理一般对话和咨询请求",
            llm_config=llm_config
        )
        
        # 对话模式分类
        self.conversation_patterns = {
            "greeting": [
                "你好", "您好", "在吗", "hi", "hello", "早上好", "下午好", "晚上好"
            ],
            "thanks": [
                "谢谢", "感谢", "多谢", "好的", "知道了", "明白了", "收到"
            ],
            "capabilities": [
                "你能做什么", "有什么功能", "如何使用", "怎么用", "功能介绍", "帮助"
            ],
            "explanation": [
                "什么是", "能解释", "介绍一下", "是什么意思", "什么叫", "定义"
            ],
            "general": [
                "为什么", "怎么样", "如何", "怎么办", "建议", "推荐"
            ]
        }
    
    def get_tools(self) -> list:
        """对话智能体不需要工具"""
        return []
    
    def get_system_prompt(self) -> str:
        """获取系统提示词"""
        return "你是一个友好的债券分析助手，负责处理用户的对话请求。请用亲切友好的语气与用户交流。"
    
    async def stream_analyze(self, user_input: str, thread_id: Optional[str] = None, **kwargs):
        """
        流式对话处理
        
        Args:
            user_input: 用户输入
            thread_id: 线程ID
            **kwargs: 额外参数
            
        Yields:
            对话事件流
        """
        try:
            # 产生开始步骤事件
            yield {
                "type": "step",
                "step": "💬 智能对话",
                "message": "正在处理对话请求..."
            }
            
            # ✅ 修复：从记忆系统获取对话历史
            conversation_history = ""
            if thread_id:
                from memory import memory_manager
                conversation_history = memory_manager.get_context_for_query(thread_id, user_input)
                self.logger.info(f"获取对话历史: {len(conversation_history)} 字符")
            
            # 调用analyze获取结果，传入对话历史
            result = await self.analyze(user_input, conversation_history=conversation_history, thread_id=thread_id, **kwargs)
            
            # 结束步骤
            yield {
                "type": "step_end"
            }
            
            # 提取响应内容
            if isinstance(result, dict):
                if "data" in result:
                    data = result["data"]
                    if isinstance(data, dict) and "response" in data:
                        content = data["response"]
                    else:
                        content = str(data)
                elif "response" in result:
                    content = result["response"]
                else:
                    content = str(result)
            else:
                content = str(result)
            
            # 产生最终结果事件
            yield {
                "type": "final_result",
                "content": content
            }
            
        except Exception as e:
            self.logger.error(f"流式对话处理失败: {e}")
            yield {
                "type": "error",
                "error": str(e)
            }
    
    async def analyze(self, user_input: str, conversation_history: str = "", **kwargs) -> Dict[str, Any]:
        """
        处理对话请求
        
        Args:
            user_input: 用户输入的自然语言文本
            conversation_history: 对话历史上下文
            **kwargs: 额外参数
            
        Returns:
            对话响应结果
        """
        try:
            # 验证输入
            if not user_input or not isinstance(user_input, str):
                return self.handle_error(
                    ValueError("用户输入不能为空"), str(user_input)
                )
            
            self.logger.info(f"处理对话请求: '{user_input[:50]}...'")
            
            # 分类对话类型
            conversation_type = self._classify_conversation_type(user_input)
            
            # 执行对话处理
            result = await self._execute_conversation(
                user_input, conversation_history, conversation_type
            )
            
            # 格式化响应
            return self.format_response(result)
            
        except Exception as e:
            return self.handle_error(e, user_input, "对话处理")
    
    def _classify_conversation_type(self, user_input: str) -> str:
        """分类对话类型"""
        user_input_lower = user_input.lower()
        
        for pattern_type, patterns in self.conversation_patterns.items():
            for pattern in patterns:
                if pattern in user_input_lower:
                    return pattern_type
        
        # 默认分类为一般咨询
        return "general"
    
    async def _execute_conversation(self, user_input: str, conversation_history: str, 
                                   conversation_type: str) -> Dict[str, Any]:
        """执行对话处理逻辑"""
        try:
            # 构建系统消息
            system_message = self._get_system_message(conversation_type)
            
            # 构建消息
            messages = [
                SystemMessage(content=system_message),
                HumanMessage(
                    content=CONVERSATION_PROMPT.format(
                        user_input=user_input,
                        conversation_history=conversation_history or "（无历史记录）",
                    )
                ),
            ]
            
            # 调用LLM
            response = self.llm.invoke(messages)
            output = response.content if hasattr(response, 'content') else str(response)
            
            # 确保output是字符串类型
            if isinstance(output, list):
                output = ' '.join([str(item) for item in output])
            elif not isinstance(output, str):
                output = str(output)
            
            # 清理输出
            cleaned_output = self._clean_response(output)
            
            # 构建结果
            result = {
                "response": cleaned_output,
                "conversation_type": conversation_type,
                "input_analysis": self._analyze_input(user_input),
                "response_length": len(cleaned_output),
                "requires_follow_up": self._requires_follow_up(cleaned_output),
            }
            
            # 添加对话建议
            result["suggested_responses"] = self._generate_suggested_responses(
                conversation_type, user_input
            )
            
            return result
            
        except Exception as e:
            # 返回默认响应
            return self._get_default_response(user_input, str(e))
    
    def _get_system_message(self, conversation_type: str) -> str:
        """根据对话类型获取系统消息"""
        system_messages = {
            "greeting": "你是一个友好的债券分析助手，正在处理用户的问候。请用亲切的语气回应。",
            "thanks": "你是一个礼貌的债券分析助手，正在处理用户的感谢。请用谦虚的语气回应。",
            "capabilities": "你是一个专业的债券分析助手，正在介绍系统功能。请清晰、有条理地介绍主要功能。",
            "explanation": "你是一个知识渊博的债券分析专家，正在解释债券相关概念。请用通俗易懂的方式解释。",
            "general": "你是一个专业的债券分析助手，正在回答用户的一般咨询。请提供准确、有用的信息。"
        }
        
        return system_messages.get(conversation_type, system_messages["general"])
    
    def _clean_response(self, response: str) -> str:
        """清理LLM响应"""
        # 移除多余的格式标记
        response = re.sub(r'```.*?```', '', response, flags=re.DOTALL)
        response = re.sub(r'【.*?】', '', response)
        response = re.sub(r'<.*?>', '', response)
        
        # 移除多余的空行
        response = re.sub(r'\n\s*\n', '\n\n', response)
        
        # 去除首尾空白
        response = response.strip()
        
        return response
    
    def _analyze_input(self, user_input: str) -> Dict[str, Any]:
        """分析用户输入"""
        return {
            "length": len(user_input),
            "word_count": len(user_input.split()),
            "contains_question": any(marker in user_input for marker in ['?', '？', '吗', '什么', '如何']),
            "contains_bond_terms": any(term in user_input for term in ['债券', '转债', '收益率', '评级']),
            "sentiment": self._analyze_sentiment(user_input),
        }
    
    def _analyze_sentiment(self, text: str) -> str:
        """简单情感分析"""
        positive_indicators = ['谢谢', '感谢', '好', '棒', '优秀', '专业']
        negative_indicators = ['不好', '差', '错误', '问题', 'bug']
        
        text_lower = text.lower()
        
        if any(indicator in text_lower for indicator in positive_indicators):
            return "positive"
        elif any(indicator in text_lower for indicator in negative_indicators):
            return "negative"
        else:
            return "neutral"
    
    def _requires_follow_up(self, response: str) -> bool:
        """判断是否需要后续对话"""
        follow_up_indicators = [
            '还有什么', '需要了解', '可以继续', '欢迎提问', '随时咨询'
        ]
        
        return any(indicator in response for indicator in follow_up_indicators)
    
    def _generate_suggested_responses(self, conversation_type: str, user_input: str) -> List[str]:
        """生成建议回复"""
        suggestions = {
            "greeting": [
                "您好！我是债券分析助手，很高兴为您服务。",
                "有什么债券分析需求吗？我可以帮您分析债券、比较投资价值等。"
            ],
            "thanks": [
                "不客气！有什么其他问题随时问我。",
                "很高兴能帮到您！需要了解债券分析的哪个方面？"
            ],
            "capabilities": [
                "我可以帮您分析债券信用、比较投资价值、查询市场信息等。",
                "具体来说，我支持债券分析、对比分析、信息查询等功能。"
            ],
            "explanation": [
                "需要我解释其他债券概念吗？",
                "这个解释清楚了吗？还有什么疑问？"
            ],
            "general": [
                "需要更详细的信息吗？",
                "还有什么其他债券相关问题？"
            ]
        }
        
        return suggestions.get(conversation_type, [])
    
    def _get_default_response(self, user_input: str, error_msg: str) -> Dict[str, Any]:
        """获取默认响应"""
        return {
            "response": "抱歉，我暂时无法处理这个请求。您可以尝试重新表述问题，或者联系技术支持。",
            "conversation_type": "error",
            "input_analysis": self._analyze_input(user_input),
            "response_length": 0,
            "requires_follow_up": True,
            "suggested_responses": [
                "请重新表述您的问题",
                "您可以尝试询问债券分析相关的问题"
            ],
            "error": error_msg,
            "status": "fallback",
        }
    
    async def explain_concept(self, concept: str, level: str = "basic") -> Dict[str, Any]:
        """
        解释债券概念
        
        Args:
            concept: 需要解释的概念
            level: 解释深度（basic/intermediate/advanced）
            
        Returns:
            概念解释结果
        """
        prompt = f"请用{level}级别解释债券概念：{concept}"
        return await self.analyze(prompt)
    
    async def provide_guidance(self, topic: str) -> Dict[str, Any]:
        """
        提供操作指导
        
        Args:
            topic: 指导主题
            
        Returns:
            指导信息
        """
        prompt = f"请提供关于{topic}的操作指导"
        return await self.analyze(prompt)


# 便捷函数
async def handle_conversation(user_input: str, conversation_history: str = "") -> Dict[str, Any]:
    """
    处理对话的便捷函数
    
    Args:
        user_input: 用户输入
        conversation_history: 对话历史
        
    Returns:
        对话响应
    """
    agent = GeneralConversationalAgent()
    result = await agent.analyze(user_input, conversation_history)
    return result["data"] if "data" in result else result


# 全局实例
general_conversational_agent = GeneralConversationalAgent()